// $ANTLR 3.4 C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g 2012-02-05 21:38:08

	package script.grammar;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;


@SuppressWarnings({"all", "warnings", "unchecked"})
public class LocScriptParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "AND", "ARRAY_ACCESS", "ASSIGN", "BIT_AND", "BIT_NEG", "BIT_OR", "BLOCK", "CLOSE_BRACE", "CLOSE_BRACK", "CLOSE_PARENS", "COND_OP", "DEF", "DIV", "DIV_ASSIGN", "EQUALS", "EXPR", "FALSE", "FILTER", "FLOAT", "FOR", "GREATER_THAN", "GREATER_THAN_EQUALS", "ID", "INT", "LESS_THAN", "LESS_THAN_EQUALS", "MEM_ACCESS", "MINUS", "MINUS_ASSIGN", "MOD", "MULT", "MULT_ASSIGN", "NEG", "NOT", "NOT_EQUALS", "OPEN_BRACE", "OPEN_BRACK", "OPEN_PARENS", "OR", "PLUS", "PLUS_ASSIGN", "POST_DEC", "POST_INC", "PRE_DEC", "PRE_INC", "RETURN", "SHIFT_LEFT", "SHIFT_RIGHT", "THIS", "TRUE", "U_SHIFT_RIGHT", "VAR", "WS", "XOR", "'++'", "','", "'--'", "':'", "';'", "'?'"
    };

    public static final int EOF=-1;
    public static final int T__58=58;
    public static final int T__59=59;
    public static final int T__60=60;
    public static final int T__61=61;
    public static final int T__62=62;
    public static final int T__63=63;
    public static final int AND=4;
    public static final int ARRAY_ACCESS=5;
    public static final int ASSIGN=6;
    public static final int BIT_AND=7;
    public static final int BIT_NEG=8;
    public static final int BIT_OR=9;
    public static final int BLOCK=10;
    public static final int CLOSE_BRACE=11;
    public static final int CLOSE_BRACK=12;
    public static final int CLOSE_PARENS=13;
    public static final int COND_OP=14;
    public static final int DEF=15;
    public static final int DIV=16;
    public static final int DIV_ASSIGN=17;
    public static final int EQUALS=18;
    public static final int EXPR=19;
    public static final int FALSE=20;
    public static final int FILTER=21;
    public static final int FLOAT=22;
    public static final int FOR=23;
    public static final int GREATER_THAN=24;
    public static final int GREATER_THAN_EQUALS=25;
    public static final int ID=26;
    public static final int INT=27;
    public static final int LESS_THAN=28;
    public static final int LESS_THAN_EQUALS=29;
    public static final int MEM_ACCESS=30;
    public static final int MINUS=31;
    public static final int MINUS_ASSIGN=32;
    public static final int MOD=33;
    public static final int MULT=34;
    public static final int MULT_ASSIGN=35;
    public static final int NEG=36;
    public static final int NOT=37;
    public static final int NOT_EQUALS=38;
    public static final int OPEN_BRACE=39;
    public static final int OPEN_BRACK=40;
    public static final int OPEN_PARENS=41;
    public static final int OR=42;
    public static final int PLUS=43;
    public static final int PLUS_ASSIGN=44;
    public static final int POST_DEC=45;
    public static final int POST_INC=46;
    public static final int PRE_DEC=47;
    public static final int PRE_INC=48;
    public static final int RETURN=49;
    public static final int SHIFT_LEFT=50;
    public static final int SHIFT_RIGHT=51;
    public static final int THIS=52;
    public static final int TRUE=53;
    public static final int U_SHIFT_RIGHT=54;
    public static final int VAR=55;
    public static final int WS=56;
    public static final int XOR=57;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public LocScriptParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public LocScriptParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
        this.state.ruleMemo = new HashMap[26+1];
         

    }

protected TreeAdaptor adaptor = new CommonTreeAdaptor();

public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}
    public String[] getTokenNames() { return LocScriptParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g"; }


    public static class start_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "start"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:85:1: start : ( stat )* EOF -> ^( FILTER ( stat )* ) ;
    public final LocScriptParser.start_return start() throws RecognitionException {
        LocScriptParser.start_return retval = new LocScriptParser.start_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token EOF2=null;
        LocScriptParser.stat_return stat1 =null;


        LocScriptAST EOF2_tree=null;
        RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
        RewriteRuleSubtreeStream stream_stat=new RewriteRuleSubtreeStream(adaptor,"rule stat");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:86:2: ( ( stat )* EOF -> ^( FILTER ( stat )* ) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:86:4: ( stat )* EOF
            {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:86:4: ( stat )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==BIT_NEG||LA1_0==FALSE||(LA1_0 >= FLOAT && LA1_0 <= FOR)||LA1_0==INT||(LA1_0 >= MEM_ACCESS && LA1_0 <= MINUS)||LA1_0==OPEN_PARENS||LA1_0==RETURN||LA1_0==TRUE||LA1_0==VAR||LA1_0==58||LA1_0==60) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:86:4: stat
            	    {
            	    pushFollow(FOLLOW_stat_in_start458);
            	    stat1=stat();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_stat.add(stat1.getTree());

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_start461); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_EOF.add(EOF2);


            // AST REWRITE
            // elements: stat
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (LocScriptAST)adaptor.nil();
            // 86:14: -> ^( FILTER ( stat )* )
            {
                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:86:17: ^( FILTER ( stat )* )
                {
                LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                root_1 = (LocScriptAST)adaptor.becomeRoot(
                (LocScriptAST)adaptor.create(FILTER, "FILTER")
                , root_1);

                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:86:26: ( stat )*
                while ( stream_stat.hasNext() ) {
                    adaptor.addChild(root_1, stream_stat.nextTree());

                }
                stream_stat.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "start"


    public static class block_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "block"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:89:1: block : ( stat )* -> ^( BLOCK ( stat )* ) ;
    public final LocScriptParser.block_return block() throws RecognitionException {
        LocScriptParser.block_return retval = new LocScriptParser.block_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        LocScriptParser.stat_return stat3 =null;


        RewriteRuleSubtreeStream stream_stat=new RewriteRuleSubtreeStream(adaptor,"rule stat");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:90:2: ( ( stat )* -> ^( BLOCK ( stat )* ) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:90:4: ( stat )*
            {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:90:4: ( stat )*
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( (LA2_0==BIT_NEG||LA2_0==FALSE||(LA2_0 >= FLOAT && LA2_0 <= FOR)||LA2_0==INT||(LA2_0 >= MEM_ACCESS && LA2_0 <= MINUS)||LA2_0==OPEN_PARENS||LA2_0==RETURN||LA2_0==TRUE||LA2_0==VAR||LA2_0==58||LA2_0==60) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:90:4: stat
            	    {
            	    pushFollow(FOLLOW_stat_in_block482);
            	    stat3=stat();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_stat.add(stat3.getTree());

            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);


            // AST REWRITE
            // elements: stat
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (LocScriptAST)adaptor.nil();
            // 90:10: -> ^( BLOCK ( stat )* )
            {
                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:90:13: ^( BLOCK ( stat )* )
                {
                LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                root_1 = (LocScriptAST)adaptor.becomeRoot(
                (LocScriptAST)adaptor.create(BLOCK, "BLOCK")
                , root_1);

                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:90:21: ( stat )*
                while ( stream_stat.hasNext() ) {
                    adaptor.addChild(root_1, stream_stat.nextTree());

                }
                stream_stat.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "block"


    public static class foreach_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "foreach"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:93:1: foreach : FOR OPEN_PARENS defCore ':' expr CLOSE_PARENS OPEN_BRACE block CLOSE_BRACE -> ^( FOR ^( DEF defCore ) expr block ) ;
    public final LocScriptParser.foreach_return foreach() throws RecognitionException {
        LocScriptParser.foreach_return retval = new LocScriptParser.foreach_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token FOR4=null;
        Token OPEN_PARENS5=null;
        Token char_literal7=null;
        Token CLOSE_PARENS9=null;
        Token OPEN_BRACE10=null;
        Token CLOSE_BRACE12=null;
        LocScriptParser.defCore_return defCore6 =null;

        LocScriptParser.expr_return expr8 =null;

        LocScriptParser.block_return block11 =null;


        LocScriptAST FOR4_tree=null;
        LocScriptAST OPEN_PARENS5_tree=null;
        LocScriptAST char_literal7_tree=null;
        LocScriptAST CLOSE_PARENS9_tree=null;
        LocScriptAST OPEN_BRACE10_tree=null;
        LocScriptAST CLOSE_BRACE12_tree=null;
        RewriteRuleTokenStream stream_FOR=new RewriteRuleTokenStream(adaptor,"token FOR");
        RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
        RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
        RewriteRuleTokenStream stream_OPEN_PARENS=new RewriteRuleTokenStream(adaptor,"token OPEN_PARENS");
        RewriteRuleTokenStream stream_61=new RewriteRuleTokenStream(adaptor,"token 61");
        RewriteRuleTokenStream stream_CLOSE_PARENS=new RewriteRuleTokenStream(adaptor,"token CLOSE_PARENS");
        RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
        RewriteRuleSubtreeStream stream_defCore=new RewriteRuleSubtreeStream(adaptor,"rule defCore");
        RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:94:2: ( FOR OPEN_PARENS defCore ':' expr CLOSE_PARENS OPEN_BRACE block CLOSE_BRACE -> ^( FOR ^( DEF defCore ) expr block ) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:94:4: FOR OPEN_PARENS defCore ':' expr CLOSE_PARENS OPEN_BRACE block CLOSE_BRACE
            {
            FOR4=(Token)match(input,FOR,FOLLOW_FOR_in_foreach504); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_FOR.add(FOR4);


            OPEN_PARENS5=(Token)match(input,OPEN_PARENS,FOLLOW_OPEN_PARENS_in_foreach506); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_OPEN_PARENS.add(OPEN_PARENS5);


            pushFollow(FOLLOW_defCore_in_foreach508);
            defCore6=defCore();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_defCore.add(defCore6.getTree());

            char_literal7=(Token)match(input,61,FOLLOW_61_in_foreach510); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_61.add(char_literal7);


            pushFollow(FOLLOW_expr_in_foreach512);
            expr8=expr();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_expr.add(expr8.getTree());

            CLOSE_PARENS9=(Token)match(input,CLOSE_PARENS,FOLLOW_CLOSE_PARENS_in_foreach514); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_CLOSE_PARENS.add(CLOSE_PARENS9);


            OPEN_BRACE10=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_foreach516); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_OPEN_BRACE.add(OPEN_BRACE10);


            pushFollow(FOLLOW_block_in_foreach518);
            block11=block();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_block.add(block11.getTree());

            CLOSE_BRACE12=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_foreach520); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_CLOSE_BRACE.add(CLOSE_BRACE12);


            // AST REWRITE
            // elements: defCore, FOR, expr, block
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (LocScriptAST)adaptor.nil();
            // 95:3: -> ^( FOR ^( DEF defCore ) expr block )
            {
                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:95:6: ^( FOR ^( DEF defCore ) expr block )
                {
                LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                root_1 = (LocScriptAST)adaptor.becomeRoot(
                stream_FOR.nextNode()
                , root_1);

                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:95:12: ^( DEF defCore )
                {
                LocScriptAST root_2 = (LocScriptAST)adaptor.nil();
                root_2 = (LocScriptAST)adaptor.becomeRoot(
                (LocScriptAST)adaptor.create(DEF, "DEF")
                , root_2);

                adaptor.addChild(root_2, stream_defCore.nextTree());

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_1, stream_expr.nextTree());

                adaptor.addChild(root_1, stream_block.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "foreach"


    public static class defList_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "defList"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:98:1: defList : def ( ',' ! def )* ;
    public final LocScriptParser.defList_return defList() throws RecognitionException {
        LocScriptParser.defList_return retval = new LocScriptParser.defList_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token char_literal14=null;
        LocScriptParser.def_return def13 =null;

        LocScriptParser.def_return def15 =null;


        LocScriptAST char_literal14_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:99:2: ( def ( ',' ! def )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:99:4: def ( ',' ! def )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_def_in_defList550);
            def13=def();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, def13.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:99:8: ( ',' ! def )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( (LA3_0==59) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:99:9: ',' ! def
            	    {
            	    char_literal14=(Token)match(input,59,FOLLOW_59_in_defList553); if (state.failed) return retval;

            	    pushFollow(FOLLOW_def_in_defList556);
            	    def15=def();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, def15.getTree());

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "defList"


    public static class def_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "def"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:102:1: def : defCore ( ASSIGN expr )? -> ^( DEF defCore ( expr )? ) ;
    public final LocScriptParser.def_return def() throws RecognitionException {
        LocScriptParser.def_return retval = new LocScriptParser.def_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token ASSIGN17=null;
        LocScriptParser.defCore_return defCore16 =null;

        LocScriptParser.expr_return expr18 =null;


        LocScriptAST ASSIGN17_tree=null;
        RewriteRuleTokenStream stream_ASSIGN=new RewriteRuleTokenStream(adaptor,"token ASSIGN");
        RewriteRuleSubtreeStream stream_defCore=new RewriteRuleSubtreeStream(adaptor,"rule defCore");
        RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:102:5: ( defCore ( ASSIGN expr )? -> ^( DEF defCore ( expr )? ) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:102:7: defCore ( ASSIGN expr )?
            {
            pushFollow(FOLLOW_defCore_in_def569);
            defCore16=defCore();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_defCore.add(defCore16.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:102:15: ( ASSIGN expr )?
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==ASSIGN) ) {
                alt4=1;
            }
            switch (alt4) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:102:16: ASSIGN expr
                    {
                    ASSIGN17=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_def572); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_ASSIGN.add(ASSIGN17);


                    pushFollow(FOLLOW_expr_in_def574);
                    expr18=expr();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expr.add(expr18.getTree());

                    }
                    break;

            }


            // AST REWRITE
            // elements: defCore, expr
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (LocScriptAST)adaptor.nil();
            // 102:30: -> ^( DEF defCore ( expr )? )
            {
                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:102:33: ^( DEF defCore ( expr )? )
                {
                LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                root_1 = (LocScriptAST)adaptor.becomeRoot(
                (LocScriptAST)adaptor.create(DEF, "DEF")
                , root_1);

                adaptor.addChild(root_1, stream_defCore.nextTree());

                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:102:47: ( expr )?
                if ( stream_expr.hasNext() ) {
                    adaptor.addChild(root_1, stream_expr.nextTree());

                }
                stream_expr.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "def"


    public static class defCore_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "defCore"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:105:1: defCore : VAR ! ID OPEN_PARENS ! ID CLOSE_PARENS !;
    public final LocScriptParser.defCore_return defCore() throws RecognitionException {
        LocScriptParser.defCore_return retval = new LocScriptParser.defCore_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token VAR19=null;
        Token ID20=null;
        Token OPEN_PARENS21=null;
        Token ID22=null;
        Token CLOSE_PARENS23=null;

        LocScriptAST VAR19_tree=null;
        LocScriptAST ID20_tree=null;
        LocScriptAST OPEN_PARENS21_tree=null;
        LocScriptAST ID22_tree=null;
        LocScriptAST CLOSE_PARENS23_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:106:2: ( VAR ! ID OPEN_PARENS ! ID CLOSE_PARENS !)
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:106:4: VAR ! ID OPEN_PARENS ! ID CLOSE_PARENS !
            {
            root_0 = (LocScriptAST)adaptor.nil();


            VAR19=(Token)match(input,VAR,FOLLOW_VAR_in_defCore599); if (state.failed) return retval;

            ID20=(Token)match(input,ID,FOLLOW_ID_in_defCore602); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            ID20_tree = 
            (LocScriptAST)adaptor.create(ID20)
            ;
            adaptor.addChild(root_0, ID20_tree);
            }

            OPEN_PARENS21=(Token)match(input,OPEN_PARENS,FOLLOW_OPEN_PARENS_in_defCore604); if (state.failed) return retval;

            ID22=(Token)match(input,ID,FOLLOW_ID_in_defCore607); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            ID22_tree = 
            (LocScriptAST)adaptor.create(ID22)
            ;
            adaptor.addChild(root_0, ID22_tree);
            }

            CLOSE_PARENS23=(Token)match(input,CLOSE_PARENS,FOLLOW_CLOSE_PARENS_in_defCore609); if (state.failed) return retval;

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "defCore"


    public static class expr_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:109:1: expr : expr0 -> ^( EXPR expr0 ) ;
    public final LocScriptParser.expr_return expr() throws RecognitionException {
        LocScriptParser.expr_return retval = new LocScriptParser.expr_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        LocScriptParser.expr0_return expr024 =null;


        RewriteRuleSubtreeStream stream_expr0=new RewriteRuleSubtreeStream(adaptor,"rule expr0");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:109:5: ( expr0 -> ^( EXPR expr0 ) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:109:7: expr0
            {
            pushFollow(FOLLOW_expr0_in_expr623);
            expr024=expr0();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_expr0.add(expr024.getTree());

            // AST REWRITE
            // elements: expr0
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (LocScriptAST)adaptor.nil();
            // 109:13: -> ^( EXPR expr0 )
            {
                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:109:16: ^( EXPR expr0 )
                {
                LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                root_1 = (LocScriptAST)adaptor.becomeRoot(
                (LocScriptAST)adaptor.create(EXPR, "EXPR")
                , root_1);

                adaptor.addChild(root_1, stream_expr0.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr"


    public static class expr0_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr0"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:112:1: expr0 : ( VAR ID (a= ASSIGN |a= PLUS_ASSIGN |a= MINUS_ASSIGN |a= MULT_ASSIGN |a= DIV_ASSIGN ) expr0 -> ^( $a ^( VAR ID ) expr0 ) | expr1 );
    public final LocScriptParser.expr0_return expr0() throws RecognitionException {
        LocScriptParser.expr0_return retval = new LocScriptParser.expr0_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token a=null;
        Token VAR25=null;
        Token ID26=null;
        LocScriptParser.expr0_return expr027 =null;

        LocScriptParser.expr1_return expr128 =null;


        LocScriptAST a_tree=null;
        LocScriptAST VAR25_tree=null;
        LocScriptAST ID26_tree=null;
        RewriteRuleTokenStream stream_VAR=new RewriteRuleTokenStream(adaptor,"token VAR");
        RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
        RewriteRuleTokenStream stream_DIV_ASSIGN=new RewriteRuleTokenStream(adaptor,"token DIV_ASSIGN");
        RewriteRuleTokenStream stream_MULT_ASSIGN=new RewriteRuleTokenStream(adaptor,"token MULT_ASSIGN");
        RewriteRuleTokenStream stream_MINUS_ASSIGN=new RewriteRuleTokenStream(adaptor,"token MINUS_ASSIGN");
        RewriteRuleTokenStream stream_ASSIGN=new RewriteRuleTokenStream(adaptor,"token ASSIGN");
        RewriteRuleTokenStream stream_PLUS_ASSIGN=new RewriteRuleTokenStream(adaptor,"token PLUS_ASSIGN");
        RewriteRuleSubtreeStream stream_expr0=new RewriteRuleSubtreeStream(adaptor,"rule expr0");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:2: ( VAR ID (a= ASSIGN |a= PLUS_ASSIGN |a= MINUS_ASSIGN |a= MULT_ASSIGN |a= DIV_ASSIGN ) expr0 -> ^( $a ^( VAR ID ) expr0 ) | expr1 )
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==VAR) ) {
                int LA6_1 = input.LA(2);

                if ( (LA6_1==ID) ) {
                    int LA6_3 = input.LA(3);

                    if ( (LA6_3==ASSIGN||LA6_3==DIV_ASSIGN||LA6_3==MINUS_ASSIGN||LA6_3==MULT_ASSIGN||LA6_3==PLUS_ASSIGN) ) {
                        alt6=1;
                    }
                    else if ( (LA6_3==EOF||LA6_3==AND||LA6_3==BIT_AND||LA6_3==BIT_OR||(LA6_3 >= CLOSE_BRACK && LA6_3 <= CLOSE_PARENS)||LA6_3==DIV||LA6_3==EQUALS||(LA6_3 >= GREATER_THAN && LA6_3 <= GREATER_THAN_EQUALS)||(LA6_3 >= LESS_THAN && LA6_3 <= MINUS)||(LA6_3 >= MOD && LA6_3 <= MULT)||LA6_3==NOT_EQUALS||LA6_3==OPEN_BRACK||(LA6_3 >= OR && LA6_3 <= PLUS)||(LA6_3 >= SHIFT_LEFT && LA6_3 <= SHIFT_RIGHT)||LA6_3==U_SHIFT_RIGHT||(LA6_3 >= XOR && LA6_3 <= 63)) ) {
                        alt6=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 6, 3, input);

                        throw nvae;

                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 6, 1, input);

                    throw nvae;

                }
            }
            else if ( (LA6_0==BIT_NEG||LA6_0==FALSE||LA6_0==FLOAT||LA6_0==INT||(LA6_0 >= MEM_ACCESS && LA6_0 <= MINUS)||LA6_0==OPEN_PARENS||LA6_0==TRUE||LA6_0==58||LA6_0==60) ) {
                alt6=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;

            }
            switch (alt6) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:4: VAR ID (a= ASSIGN |a= PLUS_ASSIGN |a= MINUS_ASSIGN |a= MULT_ASSIGN |a= DIV_ASSIGN ) expr0
                    {
                    VAR25=(Token)match(input,VAR,FOLLOW_VAR_in_expr0643); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_VAR.add(VAR25);


                    ID26=(Token)match(input,ID,FOLLOW_ID_in_expr0645); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_ID.add(ID26);


                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:11: (a= ASSIGN |a= PLUS_ASSIGN |a= MINUS_ASSIGN |a= MULT_ASSIGN |a= DIV_ASSIGN )
                    int alt5=5;
                    switch ( input.LA(1) ) {
                    case ASSIGN:
                        {
                        alt5=1;
                        }
                        break;
                    case PLUS_ASSIGN:
                        {
                        alt5=2;
                        }
                        break;
                    case MINUS_ASSIGN:
                        {
                        alt5=3;
                        }
                        break;
                    case MULT_ASSIGN:
                        {
                        alt5=4;
                        }
                        break;
                    case DIV_ASSIGN:
                        {
                        alt5=5;
                        }
                        break;
                    default:
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 5, 0, input);

                        throw nvae;

                    }

                    switch (alt5) {
                        case 1 :
                            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:12: a= ASSIGN
                            {
                            a=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_expr0650); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_ASSIGN.add(a);


                            }
                            break;
                        case 2 :
                            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:21: a= PLUS_ASSIGN
                            {
                            a=(Token)match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_expr0654); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_PLUS_ASSIGN.add(a);


                            }
                            break;
                        case 3 :
                            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:35: a= MINUS_ASSIGN
                            {
                            a=(Token)match(input,MINUS_ASSIGN,FOLLOW_MINUS_ASSIGN_in_expr0658); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_MINUS_ASSIGN.add(a);


                            }
                            break;
                        case 4 :
                            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:50: a= MULT_ASSIGN
                            {
                            a=(Token)match(input,MULT_ASSIGN,FOLLOW_MULT_ASSIGN_in_expr0662); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_MULT_ASSIGN.add(a);


                            }
                            break;
                        case 5 :
                            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:64: a= DIV_ASSIGN
                            {
                            a=(Token)match(input,DIV_ASSIGN,FOLLOW_DIV_ASSIGN_in_expr0666); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_DIV_ASSIGN.add(a);


                            }
                            break;

                    }


                    pushFollow(FOLLOW_expr0_in_expr0669);
                    expr027=expr0();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expr0.add(expr027.getTree());

                    // AST REWRITE
                    // elements: VAR, expr0, a, ID
                    // token labels: a
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleTokenStream stream_a=new RewriteRuleTokenStream(adaptor,"token a",a);
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocScriptAST)adaptor.nil();
                    // 113:84: -> ^( $a ^( VAR ID ) expr0 )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:87: ^( $a ^( VAR ID ) expr0 )
                        {
                        LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                        root_1 = (LocScriptAST)adaptor.becomeRoot(stream_a.nextNode(), root_1);

                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:113:92: ^( VAR ID )
                        {
                        LocScriptAST root_2 = (LocScriptAST)adaptor.nil();
                        root_2 = (LocScriptAST)adaptor.becomeRoot(
                        stream_VAR.nextNode()
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_ID.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        adaptor.addChild(root_1, stream_expr0.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:114:4: expr1
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    pushFollow(FOLLOW_expr1_in_expr0689);
                    expr128=expr1();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr128.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr0"


    public static class expr1_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr1"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:117:1: expr1 options {backtrack=true; memoize=true; } : ( expr2 '?' a= expr0 ':' b= expr0 -> ^( COND_OP expr2 $a $b) | expr2 );
    public final LocScriptParser.expr1_return expr1() throws RecognitionException {
        LocScriptParser.expr1_return retval = new LocScriptParser.expr1_return();
        retval.start = input.LT(1);

        int expr1_StartIndex = input.index();

        LocScriptAST root_0 = null;

        Token char_literal30=null;
        Token char_literal31=null;
        LocScriptParser.expr0_return a =null;

        LocScriptParser.expr0_return b =null;

        LocScriptParser.expr2_return expr229 =null;

        LocScriptParser.expr2_return expr232 =null;


        LocScriptAST char_literal30_tree=null;
        LocScriptAST char_literal31_tree=null;
        RewriteRuleTokenStream stream_63=new RewriteRuleTokenStream(adaptor,"token 63");
        RewriteRuleTokenStream stream_61=new RewriteRuleTokenStream(adaptor,"token 61");
        RewriteRuleSubtreeStream stream_expr0=new RewriteRuleSubtreeStream(adaptor,"rule expr0");
        RewriteRuleSubtreeStream stream_expr2=new RewriteRuleSubtreeStream(adaptor,"rule expr2");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return retval; }

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:119:2: ( expr2 '?' a= expr0 ':' b= expr0 -> ^( COND_OP expr2 $a $b) | expr2 )
            int alt7=2;
            switch ( input.LA(1) ) {
            case MINUS:
                {
                int LA7_1 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 1, input);

                    throw nvae;

                }
                }
                break;
            case BIT_NEG:
                {
                int LA7_2 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 2, input);

                    throw nvae;

                }
                }
                break;
            case 58:
                {
                int LA7_3 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 3, input);

                    throw nvae;

                }
                }
                break;
            case 60:
                {
                int LA7_4 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 4, input);

                    throw nvae;

                }
                }
                break;
            case INT:
                {
                int LA7_5 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 5, input);

                    throw nvae;

                }
                }
                break;
            case FLOAT:
                {
                int LA7_6 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 6, input);

                    throw nvae;

                }
                }
                break;
            case TRUE:
                {
                int LA7_7 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 7, input);

                    throw nvae;

                }
                }
                break;
            case FALSE:
                {
                int LA7_8 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 8, input);

                    throw nvae;

                }
                }
                break;
            case VAR:
                {
                int LA7_9 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 9, input);

                    throw nvae;

                }
                }
                break;
            case MEM_ACCESS:
                {
                int LA7_10 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 10, input);

                    throw nvae;

                }
                }
                break;
            case OPEN_PARENS:
                {
                int LA7_11 = input.LA(2);

                if ( (synpred1_LocScript()) ) {
                    alt7=1;
                }
                else if ( (true) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 11, input);

                    throw nvae;

                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;

            }

            switch (alt7) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:119:4: expr2 '?' a= expr0 ':' b= expr0
                    {
                    pushFollow(FOLLOW_expr2_in_expr1712);
                    expr229=expr2();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expr2.add(expr229.getTree());

                    char_literal30=(Token)match(input,63,FOLLOW_63_in_expr1714); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_63.add(char_literal30);


                    pushFollow(FOLLOW_expr0_in_expr1718);
                    a=expr0();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expr0.add(a.getTree());

                    char_literal31=(Token)match(input,61,FOLLOW_61_in_expr1720); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_61.add(char_literal31);


                    pushFollow(FOLLOW_expr0_in_expr1724);
                    b=expr0();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expr0.add(b.getTree());

                    // AST REWRITE
                    // elements: a, b, expr2
                    // token labels: 
                    // rule labels: retval, b, a
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_b=new RewriteRuleSubtreeStream(adaptor,"rule b",b!=null?b.tree:null);
                    RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);

                    root_0 = (LocScriptAST)adaptor.nil();
                    // 119:34: -> ^( COND_OP expr2 $a $b)
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:119:37: ^( COND_OP expr2 $a $b)
                        {
                        LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                        root_1 = (LocScriptAST)adaptor.becomeRoot(
                        (LocScriptAST)adaptor.create(COND_OP, "COND_OP")
                        , root_1);

                        adaptor.addChild(root_1, stream_expr2.nextTree());

                        adaptor.addChild(root_1, stream_a.nextTree());

                        adaptor.addChild(root_1, stream_b.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:120:4: expr2
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    pushFollow(FOLLOW_expr2_in_expr1743);
                    expr232=expr2();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr232.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 9, expr1_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "expr1"


    public static class expr2_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr2"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:123:1: expr2 : expr3 ( OR ^ expr3 )* ;
    public final LocScriptParser.expr2_return expr2() throws RecognitionException {
        LocScriptParser.expr2_return retval = new LocScriptParser.expr2_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token OR34=null;
        LocScriptParser.expr3_return expr333 =null;

        LocScriptParser.expr3_return expr335 =null;


        LocScriptAST OR34_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:124:2: ( expr3 ( OR ^ expr3 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:124:4: expr3 ( OR ^ expr3 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr3_in_expr2755);
            expr333=expr3();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr333.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:124:10: ( OR ^ expr3 )*
            loop8:
            do {
                int alt8=2;
                int LA8_0 = input.LA(1);

                if ( (LA8_0==OR) ) {
                    alt8=1;
                }


                switch (alt8) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:124:11: OR ^ expr3
            	    {
            	    OR34=(Token)match(input,OR,FOLLOW_OR_in_expr2758); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    OR34_tree = 
            	    (LocScriptAST)adaptor.create(OR34)
            	    ;
            	    root_0 = (LocScriptAST)adaptor.becomeRoot(OR34_tree, root_0);
            	    }

            	    pushFollow(FOLLOW_expr3_in_expr2761);
            	    expr335=expr3();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr335.getTree());

            	    }
            	    break;

            	default :
            	    break loop8;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr2"


    public static class expr3_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr3"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:127:1: expr3 : expr4 ( AND ^ expr4 )* ;
    public final LocScriptParser.expr3_return expr3() throws RecognitionException {
        LocScriptParser.expr3_return retval = new LocScriptParser.expr3_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token AND37=null;
        LocScriptParser.expr4_return expr436 =null;

        LocScriptParser.expr4_return expr438 =null;


        LocScriptAST AND37_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:128:2: ( expr4 ( AND ^ expr4 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:128:4: expr4 ( AND ^ expr4 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr4_in_expr3775);
            expr436=expr4();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr436.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:128:10: ( AND ^ expr4 )*
            loop9:
            do {
                int alt9=2;
                int LA9_0 = input.LA(1);

                if ( (LA9_0==AND) ) {
                    alt9=1;
                }


                switch (alt9) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:128:11: AND ^ expr4
            	    {
            	    AND37=(Token)match(input,AND,FOLLOW_AND_in_expr3778); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    AND37_tree = 
            	    (LocScriptAST)adaptor.create(AND37)
            	    ;
            	    root_0 = (LocScriptAST)adaptor.becomeRoot(AND37_tree, root_0);
            	    }

            	    pushFollow(FOLLOW_expr4_in_expr3781);
            	    expr438=expr4();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr438.getTree());

            	    }
            	    break;

            	default :
            	    break loop9;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr3"


    public static class expr4_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr4"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:131:1: expr4 : expr5 ( BIT_OR ^ expr5 )* ;
    public final LocScriptParser.expr4_return expr4() throws RecognitionException {
        LocScriptParser.expr4_return retval = new LocScriptParser.expr4_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token BIT_OR40=null;
        LocScriptParser.expr5_return expr539 =null;

        LocScriptParser.expr5_return expr541 =null;


        LocScriptAST BIT_OR40_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:132:2: ( expr5 ( BIT_OR ^ expr5 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:132:4: expr5 ( BIT_OR ^ expr5 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr5_in_expr4795);
            expr539=expr5();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr539.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:132:10: ( BIT_OR ^ expr5 )*
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( (LA10_0==BIT_OR) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:132:11: BIT_OR ^ expr5
            	    {
            	    BIT_OR40=(Token)match(input,BIT_OR,FOLLOW_BIT_OR_in_expr4798); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    BIT_OR40_tree = 
            	    (LocScriptAST)adaptor.create(BIT_OR40)
            	    ;
            	    root_0 = (LocScriptAST)adaptor.becomeRoot(BIT_OR40_tree, root_0);
            	    }

            	    pushFollow(FOLLOW_expr5_in_expr4801);
            	    expr541=expr5();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr541.getTree());

            	    }
            	    break;

            	default :
            	    break loop10;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr4"


    public static class expr5_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr5"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:135:1: expr5 : expr6 ( XOR ^ expr6 )* ;
    public final LocScriptParser.expr5_return expr5() throws RecognitionException {
        LocScriptParser.expr5_return retval = new LocScriptParser.expr5_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token XOR43=null;
        LocScriptParser.expr6_return expr642 =null;

        LocScriptParser.expr6_return expr644 =null;


        LocScriptAST XOR43_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:136:2: ( expr6 ( XOR ^ expr6 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:136:4: expr6 ( XOR ^ expr6 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr6_in_expr5815);
            expr642=expr6();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr642.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:136:10: ( XOR ^ expr6 )*
            loop11:
            do {
                int alt11=2;
                int LA11_0 = input.LA(1);

                if ( (LA11_0==XOR) ) {
                    alt11=1;
                }


                switch (alt11) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:136:11: XOR ^ expr6
            	    {
            	    XOR43=(Token)match(input,XOR,FOLLOW_XOR_in_expr5818); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    XOR43_tree = 
            	    (LocScriptAST)adaptor.create(XOR43)
            	    ;
            	    root_0 = (LocScriptAST)adaptor.becomeRoot(XOR43_tree, root_0);
            	    }

            	    pushFollow(FOLLOW_expr6_in_expr5821);
            	    expr644=expr6();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr644.getTree());

            	    }
            	    break;

            	default :
            	    break loop11;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr5"


    public static class expr6_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr6"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:139:1: expr6 : expr7 ( BIT_AND ^ expr7 )* ;
    public final LocScriptParser.expr6_return expr6() throws RecognitionException {
        LocScriptParser.expr6_return retval = new LocScriptParser.expr6_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token BIT_AND46=null;
        LocScriptParser.expr7_return expr745 =null;

        LocScriptParser.expr7_return expr747 =null;


        LocScriptAST BIT_AND46_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:140:2: ( expr7 ( BIT_AND ^ expr7 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:140:4: expr7 ( BIT_AND ^ expr7 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr7_in_expr6835);
            expr745=expr7();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr745.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:140:10: ( BIT_AND ^ expr7 )*
            loop12:
            do {
                int alt12=2;
                int LA12_0 = input.LA(1);

                if ( (LA12_0==BIT_AND) ) {
                    alt12=1;
                }


                switch (alt12) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:140:11: BIT_AND ^ expr7
            	    {
            	    BIT_AND46=(Token)match(input,BIT_AND,FOLLOW_BIT_AND_in_expr6838); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    BIT_AND46_tree = 
            	    (LocScriptAST)adaptor.create(BIT_AND46)
            	    ;
            	    root_0 = (LocScriptAST)adaptor.becomeRoot(BIT_AND46_tree, root_0);
            	    }

            	    pushFollow(FOLLOW_expr7_in_expr6841);
            	    expr747=expr7();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr747.getTree());

            	    }
            	    break;

            	default :
            	    break loop12;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr6"


    public static class expr7_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr7"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:143:1: expr7 : expr8 ( ( EQUALS | NOT_EQUALS ) ^ expr8 )* ;
    public final LocScriptParser.expr7_return expr7() throws RecognitionException {
        LocScriptParser.expr7_return retval = new LocScriptParser.expr7_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token set49=null;
        LocScriptParser.expr8_return expr848 =null;

        LocScriptParser.expr8_return expr850 =null;


        LocScriptAST set49_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:144:2: ( expr8 ( ( EQUALS | NOT_EQUALS ) ^ expr8 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:144:4: expr8 ( ( EQUALS | NOT_EQUALS ) ^ expr8 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr8_in_expr7855);
            expr848=expr8();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr848.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:144:10: ( ( EQUALS | NOT_EQUALS ) ^ expr8 )*
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( (LA13_0==EQUALS||LA13_0==NOT_EQUALS) ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:144:11: ( EQUALS | NOT_EQUALS ) ^ expr8
            	    {
            	    set49=(Token)input.LT(1);

            	    set49=(Token)input.LT(1);

            	    if ( input.LA(1)==EQUALS||input.LA(1)==NOT_EQUALS ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) root_0 = (LocScriptAST)adaptor.becomeRoot(
            	        (LocScriptAST)adaptor.create(set49)
            	        , root_0);
            	        state.errorRecovery=false;
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_expr8_in_expr7865);
            	    expr850=expr8();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr850.getTree());

            	    }
            	    break;

            	default :
            	    break loop13;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr7"


    public static class expr8_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr8"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:147:1: expr8 : expr9 ( ( LESS_THAN | GREATER_THAN | LESS_THAN_EQUALS | GREATER_THAN_EQUALS ) ^ expr9 )* ;
    public final LocScriptParser.expr8_return expr8() throws RecognitionException {
        LocScriptParser.expr8_return retval = new LocScriptParser.expr8_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token set52=null;
        LocScriptParser.expr9_return expr951 =null;

        LocScriptParser.expr9_return expr953 =null;


        LocScriptAST set52_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:148:2: ( expr9 ( ( LESS_THAN | GREATER_THAN | LESS_THAN_EQUALS | GREATER_THAN_EQUALS ) ^ expr9 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:148:4: expr9 ( ( LESS_THAN | GREATER_THAN | LESS_THAN_EQUALS | GREATER_THAN_EQUALS ) ^ expr9 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr9_in_expr8879);
            expr951=expr9();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr951.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:148:10: ( ( LESS_THAN | GREATER_THAN | LESS_THAN_EQUALS | GREATER_THAN_EQUALS ) ^ expr9 )*
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( ((LA14_0 >= GREATER_THAN && LA14_0 <= GREATER_THAN_EQUALS)||(LA14_0 >= LESS_THAN && LA14_0 <= LESS_THAN_EQUALS)) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:148:11: ( LESS_THAN | GREATER_THAN | LESS_THAN_EQUALS | GREATER_THAN_EQUALS ) ^ expr9
            	    {
            	    set52=(Token)input.LT(1);

            	    set52=(Token)input.LT(1);

            	    if ( (input.LA(1) >= GREATER_THAN && input.LA(1) <= GREATER_THAN_EQUALS)||(input.LA(1) >= LESS_THAN && input.LA(1) <= LESS_THAN_EQUALS) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) root_0 = (LocScriptAST)adaptor.becomeRoot(
            	        (LocScriptAST)adaptor.create(set52)
            	        , root_0);
            	        state.errorRecovery=false;
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_expr9_in_expr8893);
            	    expr953=expr9();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr953.getTree());

            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr8"


    public static class expr9_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr9"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:151:1: expr9 : expr10 ( ( SHIFT_LEFT | SHIFT_RIGHT | U_SHIFT_RIGHT ) ^ expr10 )* ;
    public final LocScriptParser.expr9_return expr9() throws RecognitionException {
        LocScriptParser.expr9_return retval = new LocScriptParser.expr9_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token set55=null;
        LocScriptParser.expr10_return expr1054 =null;

        LocScriptParser.expr10_return expr1056 =null;


        LocScriptAST set55_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:152:2: ( expr10 ( ( SHIFT_LEFT | SHIFT_RIGHT | U_SHIFT_RIGHT ) ^ expr10 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:152:4: expr10 ( ( SHIFT_LEFT | SHIFT_RIGHT | U_SHIFT_RIGHT ) ^ expr10 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr10_in_expr9907);
            expr1054=expr10();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr1054.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:152:11: ( ( SHIFT_LEFT | SHIFT_RIGHT | U_SHIFT_RIGHT ) ^ expr10 )*
            loop15:
            do {
                int alt15=2;
                int LA15_0 = input.LA(1);

                if ( ((LA15_0 >= SHIFT_LEFT && LA15_0 <= SHIFT_RIGHT)||LA15_0==U_SHIFT_RIGHT) ) {
                    alt15=1;
                }


                switch (alt15) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:152:12: ( SHIFT_LEFT | SHIFT_RIGHT | U_SHIFT_RIGHT ) ^ expr10
            	    {
            	    set55=(Token)input.LT(1);

            	    set55=(Token)input.LT(1);

            	    if ( (input.LA(1) >= SHIFT_LEFT && input.LA(1) <= SHIFT_RIGHT)||input.LA(1)==U_SHIFT_RIGHT ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) root_0 = (LocScriptAST)adaptor.becomeRoot(
            	        (LocScriptAST)adaptor.create(set55)
            	        , root_0);
            	        state.errorRecovery=false;
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_expr10_in_expr9919);
            	    expr1056=expr10();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr1056.getTree());

            	    }
            	    break;

            	default :
            	    break loop15;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr9"


    public static class expr10_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr10"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:155:1: expr10 : expr11 ( ( PLUS | MINUS ) ^ expr11 )* ;
    public final LocScriptParser.expr10_return expr10() throws RecognitionException {
        LocScriptParser.expr10_return retval = new LocScriptParser.expr10_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token set58=null;
        LocScriptParser.expr11_return expr1157 =null;

        LocScriptParser.expr11_return expr1159 =null;


        LocScriptAST set58_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:156:2: ( expr11 ( ( PLUS | MINUS ) ^ expr11 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:156:4: expr11 ( ( PLUS | MINUS ) ^ expr11 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr11_in_expr10933);
            expr1157=expr11();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr1157.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:156:11: ( ( PLUS | MINUS ) ^ expr11 )*
            loop16:
            do {
                int alt16=2;
                int LA16_0 = input.LA(1);

                if ( (LA16_0==MINUS||LA16_0==PLUS) ) {
                    alt16=1;
                }


                switch (alt16) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:156:12: ( PLUS | MINUS ) ^ expr11
            	    {
            	    set58=(Token)input.LT(1);

            	    set58=(Token)input.LT(1);

            	    if ( input.LA(1)==MINUS||input.LA(1)==PLUS ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) root_0 = (LocScriptAST)adaptor.becomeRoot(
            	        (LocScriptAST)adaptor.create(set58)
            	        , root_0);
            	        state.errorRecovery=false;
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_expr11_in_expr10943);
            	    expr1159=expr11();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr1159.getTree());

            	    }
            	    break;

            	default :
            	    break loop16;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr10"


    public static class expr11_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr11"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:159:1: expr11 : expr12 ( ( MULT | DIV | MOD ) ^ expr12 )* ;
    public final LocScriptParser.expr11_return expr11() throws RecognitionException {
        LocScriptParser.expr11_return retval = new LocScriptParser.expr11_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token set61=null;
        LocScriptParser.expr12_return expr1260 =null;

        LocScriptParser.expr12_return expr1262 =null;


        LocScriptAST set61_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:160:2: ( expr12 ( ( MULT | DIV | MOD ) ^ expr12 )* )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:160:4: expr12 ( ( MULT | DIV | MOD ) ^ expr12 )*
            {
            root_0 = (LocScriptAST)adaptor.nil();


            pushFollow(FOLLOW_expr12_in_expr11957);
            expr1260=expr12();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expr1260.getTree());

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:160:11: ( ( MULT | DIV | MOD ) ^ expr12 )*
            loop17:
            do {
                int alt17=2;
                int LA17_0 = input.LA(1);

                if ( (LA17_0==DIV||(LA17_0 >= MOD && LA17_0 <= MULT)) ) {
                    alt17=1;
                }


                switch (alt17) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:160:12: ( MULT | DIV | MOD ) ^ expr12
            	    {
            	    set61=(Token)input.LT(1);

            	    set61=(Token)input.LT(1);

            	    if ( input.LA(1)==DIV||(input.LA(1) >= MOD && input.LA(1) <= MULT) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) root_0 = (LocScriptAST)adaptor.becomeRoot(
            	        (LocScriptAST)adaptor.create(set61)
            	        , root_0);
            	        state.errorRecovery=false;
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_expr12_in_expr11969);
            	    expr1262=expr12();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr1262.getTree());

            	    }
            	    break;

            	default :
            	    break loop17;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr11"


    public static class expr12_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr12"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:163:1: expr12 : ( MINUS expr12 -> ^( NEG expr12 ) | BIT_NEG ^ expr12 | '++' expr13 -> ^( PRE_INC expr13 ) | '--' expr13 -> ^( PRE_DEC expr13 ) | expr13 );
    public final LocScriptParser.expr12_return expr12() throws RecognitionException {
        LocScriptParser.expr12_return retval = new LocScriptParser.expr12_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token MINUS63=null;
        Token BIT_NEG65=null;
        Token string_literal67=null;
        Token string_literal69=null;
        LocScriptParser.expr12_return expr1264 =null;

        LocScriptParser.expr12_return expr1266 =null;

        LocScriptParser.expr13_return expr1368 =null;

        LocScriptParser.expr13_return expr1370 =null;

        LocScriptParser.expr13_return expr1371 =null;


        LocScriptAST MINUS63_tree=null;
        LocScriptAST BIT_NEG65_tree=null;
        LocScriptAST string_literal67_tree=null;
        LocScriptAST string_literal69_tree=null;
        RewriteRuleTokenStream stream_58=new RewriteRuleTokenStream(adaptor,"token 58");
        RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
        RewriteRuleTokenStream stream_60=new RewriteRuleTokenStream(adaptor,"token 60");
        RewriteRuleSubtreeStream stream_expr12=new RewriteRuleSubtreeStream(adaptor,"rule expr12");
        RewriteRuleSubtreeStream stream_expr13=new RewriteRuleSubtreeStream(adaptor,"rule expr13");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:164:2: ( MINUS expr12 -> ^( NEG expr12 ) | BIT_NEG ^ expr12 | '++' expr13 -> ^( PRE_INC expr13 ) | '--' expr13 -> ^( PRE_DEC expr13 ) | expr13 )
            int alt18=5;
            switch ( input.LA(1) ) {
            case MINUS:
                {
                alt18=1;
                }
                break;
            case BIT_NEG:
                {
                alt18=2;
                }
                break;
            case 58:
                {
                alt18=3;
                }
                break;
            case 60:
                {
                alt18=4;
                }
                break;
            case FALSE:
            case FLOAT:
            case INT:
            case MEM_ACCESS:
            case OPEN_PARENS:
            case TRUE:
            case VAR:
                {
                alt18=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                throw nvae;

            }

            switch (alt18) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:164:4: MINUS expr12
                    {
                    MINUS63=(Token)match(input,MINUS,FOLLOW_MINUS_in_expr12983); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_MINUS.add(MINUS63);


                    pushFollow(FOLLOW_expr12_in_expr12985);
                    expr1264=expr12();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expr12.add(expr1264.getTree());

                    // AST REWRITE
                    // elements: expr12
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocScriptAST)adaptor.nil();
                    // 164:17: -> ^( NEG expr12 )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:164:20: ^( NEG expr12 )
                        {
                        LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                        root_1 = (LocScriptAST)adaptor.becomeRoot(
                        (LocScriptAST)adaptor.create(NEG, "NEG")
                        , root_1);

                        adaptor.addChild(root_1, stream_expr12.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:165:4: BIT_NEG ^ expr12
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    BIT_NEG65=(Token)match(input,BIT_NEG,FOLLOW_BIT_NEG_in_expr12998); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    BIT_NEG65_tree = 
                    (LocScriptAST)adaptor.create(BIT_NEG65)
                    ;
                    root_0 = (LocScriptAST)adaptor.becomeRoot(BIT_NEG65_tree, root_0);
                    }

                    pushFollow(FOLLOW_expr12_in_expr121001);
                    expr1266=expr12();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr1266.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:166:4: '++' expr13
                    {
                    string_literal67=(Token)match(input,58,FOLLOW_58_in_expr121006); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_58.add(string_literal67);


                    pushFollow(FOLLOW_expr13_in_expr121008);
                    expr1368=expr13();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expr13.add(expr1368.getTree());

                    // AST REWRITE
                    // elements: expr13
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocScriptAST)adaptor.nil();
                    // 166:16: -> ^( PRE_INC expr13 )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:166:19: ^( PRE_INC expr13 )
                        {
                        LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                        root_1 = (LocScriptAST)adaptor.becomeRoot(
                        (LocScriptAST)adaptor.create(PRE_INC, "PRE_INC")
                        , root_1);

                        adaptor.addChild(root_1, stream_expr13.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 4 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:167:4: '--' expr13
                    {
                    string_literal69=(Token)match(input,60,FOLLOW_60_in_expr121021); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_60.add(string_literal69);


                    pushFollow(FOLLOW_expr13_in_expr121023);
                    expr1370=expr13();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expr13.add(expr1370.getTree());

                    // AST REWRITE
                    // elements: expr13
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocScriptAST)adaptor.nil();
                    // 167:16: -> ^( PRE_DEC expr13 )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:167:19: ^( PRE_DEC expr13 )
                        {
                        LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                        root_1 = (LocScriptAST)adaptor.becomeRoot(
                        (LocScriptAST)adaptor.create(PRE_DEC, "PRE_DEC")
                        , root_1);

                        adaptor.addChild(root_1, stream_expr13.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 5 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:168:4: expr13
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    pushFollow(FOLLOW_expr13_in_expr121036);
                    expr1371=expr13();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr1371.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expr12"


    public static class expr13_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expr13"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:171:1: expr13 options {backtrack=true; memoize=true; } : ( ( primary -> primary ) ( ( MEM_ACCESS ID -> ^( MEM_ACCESS $expr13 ID ) | OPEN_BRACK expr0 CLOSE_BRACK -> ^( ARRAY_ACCESS $expr13 expr0 ) ) )* | primary '++' -> ^( POST_INC primary ) | primary '--' -> ^( POST_DEC primary ) );
    public final LocScriptParser.expr13_return expr13() throws RecognitionException {
        LocScriptParser.expr13_return retval = new LocScriptParser.expr13_return();
        retval.start = input.LT(1);

        int expr13_StartIndex = input.index();

        LocScriptAST root_0 = null;

        Token MEM_ACCESS73=null;
        Token ID74=null;
        Token OPEN_BRACK75=null;
        Token CLOSE_BRACK77=null;
        Token string_literal79=null;
        Token string_literal81=null;
        LocScriptParser.primary_return primary72 =null;

        LocScriptParser.expr0_return expr076 =null;

        LocScriptParser.primary_return primary78 =null;

        LocScriptParser.primary_return primary80 =null;


        LocScriptAST MEM_ACCESS73_tree=null;
        LocScriptAST ID74_tree=null;
        LocScriptAST OPEN_BRACK75_tree=null;
        LocScriptAST CLOSE_BRACK77_tree=null;
        LocScriptAST string_literal79_tree=null;
        LocScriptAST string_literal81_tree=null;
        RewriteRuleTokenStream stream_OPEN_BRACK=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACK");
        RewriteRuleTokenStream stream_58=new RewriteRuleTokenStream(adaptor,"token 58");
        RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
        RewriteRuleTokenStream stream_CLOSE_BRACK=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACK");
        RewriteRuleTokenStream stream_60=new RewriteRuleTokenStream(adaptor,"token 60");
        RewriteRuleTokenStream stream_MEM_ACCESS=new RewriteRuleTokenStream(adaptor,"token MEM_ACCESS");
        RewriteRuleSubtreeStream stream_expr0=new RewriteRuleSubtreeStream(adaptor,"rule expr0");
        RewriteRuleSubtreeStream stream_primary=new RewriteRuleSubtreeStream(adaptor,"rule primary");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return retval; }

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:173:2: ( ( primary -> primary ) ( ( MEM_ACCESS ID -> ^( MEM_ACCESS $expr13 ID ) | OPEN_BRACK expr0 CLOSE_BRACK -> ^( ARRAY_ACCESS $expr13 expr0 ) ) )* | primary '++' -> ^( POST_INC primary ) | primary '--' -> ^( POST_DEC primary ) )
            int alt21=3;
            switch ( input.LA(1) ) {
            case INT:
                {
                int LA21_1 = input.LA(2);

                if ( (synpred2_LocScript()) ) {
                    alt21=1;
                }
                else if ( (synpred3_LocScript()) ) {
                    alt21=2;
                }
                else if ( (true) ) {
                    alt21=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 21, 1, input);

                    throw nvae;

                }
                }
                break;
            case FLOAT:
                {
                int LA21_2 = input.LA(2);

                if ( (synpred2_LocScript()) ) {
                    alt21=1;
                }
                else if ( (synpred3_LocScript()) ) {
                    alt21=2;
                }
                else if ( (true) ) {
                    alt21=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 21, 2, input);

                    throw nvae;

                }
                }
                break;
            case TRUE:
                {
                int LA21_3 = input.LA(2);

                if ( (synpred2_LocScript()) ) {
                    alt21=1;
                }
                else if ( (synpred3_LocScript()) ) {
                    alt21=2;
                }
                else if ( (true) ) {
                    alt21=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 21, 3, input);

                    throw nvae;

                }
                }
                break;
            case FALSE:
                {
                int LA21_4 = input.LA(2);

                if ( (synpred2_LocScript()) ) {
                    alt21=1;
                }
                else if ( (synpred3_LocScript()) ) {
                    alt21=2;
                }
                else if ( (true) ) {
                    alt21=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 21, 4, input);

                    throw nvae;

                }
                }
                break;
            case VAR:
                {
                int LA21_5 = input.LA(2);

                if ( (synpred2_LocScript()) ) {
                    alt21=1;
                }
                else if ( (synpred3_LocScript()) ) {
                    alt21=2;
                }
                else if ( (true) ) {
                    alt21=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 21, 5, input);

                    throw nvae;

                }
                }
                break;
            case MEM_ACCESS:
                {
                int LA21_6 = input.LA(2);

                if ( (synpred2_LocScript()) ) {
                    alt21=1;
                }
                else if ( (synpred3_LocScript()) ) {
                    alt21=2;
                }
                else if ( (true) ) {
                    alt21=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 21, 6, input);

                    throw nvae;

                }
                }
                break;
            case OPEN_PARENS:
                {
                int LA21_7 = input.LA(2);

                if ( (synpred2_LocScript()) ) {
                    alt21=1;
                }
                else if ( (synpred3_LocScript()) ) {
                    alt21=2;
                }
                else if ( (true) ) {
                    alt21=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 21, 7, input);

                    throw nvae;

                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;

            }

            switch (alt21) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:173:4: ( primary -> primary ) ( ( MEM_ACCESS ID -> ^( MEM_ACCESS $expr13 ID ) | OPEN_BRACK expr0 CLOSE_BRACK -> ^( ARRAY_ACCESS $expr13 expr0 ) ) )*
                    {
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:173:4: ( primary -> primary )
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:173:5: primary
                    {
                    pushFollow(FOLLOW_primary_in_expr131060);
                    primary72=primary();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_primary.add(primary72.getTree());

                    // AST REWRITE
                    // elements: primary
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocScriptAST)adaptor.nil();
                    // 173:13: -> primary
                    {
                        adaptor.addChild(root_0, stream_primary.nextTree());

                    }


                    retval.tree = root_0;
                    }

                    }


                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:174:3: ( ( MEM_ACCESS ID -> ^( MEM_ACCESS $expr13 ID ) | OPEN_BRACK expr0 CLOSE_BRACK -> ^( ARRAY_ACCESS $expr13 expr0 ) ) )*
                    loop20:
                    do {
                        int alt20=2;
                        int LA20_0 = input.LA(1);

                        if ( (LA20_0==MEM_ACCESS||LA20_0==OPEN_BRACK) ) {
                            alt20=1;
                        }


                        switch (alt20) {
                    	case 1 :
                    	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:175:3: ( MEM_ACCESS ID -> ^( MEM_ACCESS $expr13 ID ) | OPEN_BRACK expr0 CLOSE_BRACK -> ^( ARRAY_ACCESS $expr13 expr0 ) )
                    	    {
                    	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:175:3: ( MEM_ACCESS ID -> ^( MEM_ACCESS $expr13 ID ) | OPEN_BRACK expr0 CLOSE_BRACK -> ^( ARRAY_ACCESS $expr13 expr0 ) )
                    	    int alt19=2;
                    	    int LA19_0 = input.LA(1);

                    	    if ( (LA19_0==MEM_ACCESS) ) {
                    	        alt19=1;
                    	    }
                    	    else if ( (LA19_0==OPEN_BRACK) ) {
                    	        alt19=2;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return retval;}
                    	        NoViableAltException nvae =
                    	            new NoViableAltException("", 19, 0, input);

                    	        throw nvae;

                    	    }
                    	    switch (alt19) {
                    	        case 1 :
                    	            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:175:4: MEM_ACCESS ID
                    	            {
                    	            MEM_ACCESS73=(Token)match(input,MEM_ACCESS,FOLLOW_MEM_ACCESS_in_expr131074); if (state.failed) return retval; 
                    	            if ( state.backtracking==0 ) stream_MEM_ACCESS.add(MEM_ACCESS73);


                    	            ID74=(Token)match(input,ID,FOLLOW_ID_in_expr131076); if (state.failed) return retval; 
                    	            if ( state.backtracking==0 ) stream_ID.add(ID74);


                    	            // AST REWRITE
                    	            // elements: ID, MEM_ACCESS, expr13
                    	            // token labels: 
                    	            // rule labels: retval
                    	            // token list labels: 
                    	            // rule list labels: 
                    	            // wildcard labels: 
                    	            if ( state.backtracking==0 ) {

                    	            retval.tree = root_0;
                    	            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    	            root_0 = (LocScriptAST)adaptor.nil();
                    	            // 175:18: -> ^( MEM_ACCESS $expr13 ID )
                    	            {
                    	                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:175:21: ^( MEM_ACCESS $expr13 ID )
                    	                {
                    	                LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                    	                root_1 = (LocScriptAST)adaptor.becomeRoot(
                    	                stream_MEM_ACCESS.nextNode()
                    	                , root_1);

                    	                adaptor.addChild(root_1, stream_retval.nextTree());

                    	                adaptor.addChild(root_1, 
                    	                stream_ID.nextNode()
                    	                );

                    	                adaptor.addChild(root_0, root_1);
                    	                }

                    	            }


                    	            retval.tree = root_0;
                    	            }

                    	            }
                    	            break;
                    	        case 2 :
                    	            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:176:4: OPEN_BRACK expr0 CLOSE_BRACK
                    	            {
                    	            OPEN_BRACK75=(Token)match(input,OPEN_BRACK,FOLLOW_OPEN_BRACK_in_expr131092); if (state.failed) return retval; 
                    	            if ( state.backtracking==0 ) stream_OPEN_BRACK.add(OPEN_BRACK75);


                    	            pushFollow(FOLLOW_expr0_in_expr131094);
                    	            expr076=expr0();

                    	            state._fsp--;
                    	            if (state.failed) return retval;
                    	            if ( state.backtracking==0 ) stream_expr0.add(expr076.getTree());

                    	            CLOSE_BRACK77=(Token)match(input,CLOSE_BRACK,FOLLOW_CLOSE_BRACK_in_expr131096); if (state.failed) return retval; 
                    	            if ( state.backtracking==0 ) stream_CLOSE_BRACK.add(CLOSE_BRACK77);


                    	            // AST REWRITE
                    	            // elements: expr13, expr0
                    	            // token labels: 
                    	            // rule labels: retval
                    	            // token list labels: 
                    	            // rule list labels: 
                    	            // wildcard labels: 
                    	            if ( state.backtracking==0 ) {

                    	            retval.tree = root_0;
                    	            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    	            root_0 = (LocScriptAST)adaptor.nil();
                    	            // 176:33: -> ^( ARRAY_ACCESS $expr13 expr0 )
                    	            {
                    	                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:176:36: ^( ARRAY_ACCESS $expr13 expr0 )
                    	                {
                    	                LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                    	                root_1 = (LocScriptAST)adaptor.becomeRoot(
                    	                (LocScriptAST)adaptor.create(ARRAY_ACCESS, "ARRAY_ACCESS")
                    	                , root_1);

                    	                adaptor.addChild(root_1, stream_retval.nextTree());

                    	                adaptor.addChild(root_1, stream_expr0.nextTree());

                    	                adaptor.addChild(root_0, root_1);
                    	                }

                    	            }


                    	            retval.tree = root_0;
                    	            }

                    	            }
                    	            break;

                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop20;
                        }
                    } while (true);


                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:178:4: primary '++'
                    {
                    pushFollow(FOLLOW_primary_in_expr131118);
                    primary78=primary();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_primary.add(primary78.getTree());

                    string_literal79=(Token)match(input,58,FOLLOW_58_in_expr131120); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_58.add(string_literal79);


                    // AST REWRITE
                    // elements: primary
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocScriptAST)adaptor.nil();
                    // 178:17: -> ^( POST_INC primary )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:178:20: ^( POST_INC primary )
                        {
                        LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                        root_1 = (LocScriptAST)adaptor.becomeRoot(
                        (LocScriptAST)adaptor.create(POST_INC, "POST_INC")
                        , root_1);

                        adaptor.addChild(root_1, stream_primary.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 3 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:179:4: primary '--'
                    {
                    pushFollow(FOLLOW_primary_in_expr131133);
                    primary80=primary();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_primary.add(primary80.getTree());

                    string_literal81=(Token)match(input,60,FOLLOW_60_in_expr131135); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_60.add(string_literal81);


                    // AST REWRITE
                    // elements: primary
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocScriptAST)adaptor.nil();
                    // 179:17: -> ^( POST_DEC primary )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:179:20: ^( POST_DEC primary )
                        {
                        LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                        root_1 = (LocScriptAST)adaptor.becomeRoot(
                        (LocScriptAST)adaptor.create(POST_DEC, "POST_DEC")
                        , root_1);

                        adaptor.addChild(root_1, stream_primary.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 21, expr13_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "expr13"


    public static class primary_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "primary"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:182:1: primary : ( INT | FLOAT | TRUE | FALSE | VAR ^ ID | MEM_ACCESS ID -> ^( MEM_ACCESS THIS ID ) | OPEN_PARENS ! expr0 CLOSE_PARENS !);
    public final LocScriptParser.primary_return primary() throws RecognitionException {
        LocScriptParser.primary_return retval = new LocScriptParser.primary_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token INT82=null;
        Token FLOAT83=null;
        Token TRUE84=null;
        Token FALSE85=null;
        Token VAR86=null;
        Token ID87=null;
        Token MEM_ACCESS88=null;
        Token ID89=null;
        Token OPEN_PARENS90=null;
        Token CLOSE_PARENS92=null;
        LocScriptParser.expr0_return expr091 =null;


        LocScriptAST INT82_tree=null;
        LocScriptAST FLOAT83_tree=null;
        LocScriptAST TRUE84_tree=null;
        LocScriptAST FALSE85_tree=null;
        LocScriptAST VAR86_tree=null;
        LocScriptAST ID87_tree=null;
        LocScriptAST MEM_ACCESS88_tree=null;
        LocScriptAST ID89_tree=null;
        LocScriptAST OPEN_PARENS90_tree=null;
        LocScriptAST CLOSE_PARENS92_tree=null;
        RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
        RewriteRuleTokenStream stream_MEM_ACCESS=new RewriteRuleTokenStream(adaptor,"token MEM_ACCESS");

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:183:2: ( INT | FLOAT | TRUE | FALSE | VAR ^ ID | MEM_ACCESS ID -> ^( MEM_ACCESS THIS ID ) | OPEN_PARENS ! expr0 CLOSE_PARENS !)
            int alt22=7;
            switch ( input.LA(1) ) {
            case INT:
                {
                alt22=1;
                }
                break;
            case FLOAT:
                {
                alt22=2;
                }
                break;
            case TRUE:
                {
                alt22=3;
                }
                break;
            case FALSE:
                {
                alt22=4;
                }
                break;
            case VAR:
                {
                alt22=5;
                }
                break;
            case MEM_ACCESS:
                {
                alt22=6;
                }
                break;
            case OPEN_PARENS:
                {
                alt22=7;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;

            }

            switch (alt22) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:183:4: INT
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    INT82=(Token)match(input,INT,FOLLOW_INT_in_primary1155); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    INT82_tree = 
                    (LocScriptAST)adaptor.create(INT82)
                    ;
                    adaptor.addChild(root_0, INT82_tree);
                    }

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:183:8: FLOAT
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    FLOAT83=(Token)match(input,FLOAT,FOLLOW_FLOAT_in_primary1157); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    FLOAT83_tree = 
                    (LocScriptAST)adaptor.create(FLOAT83)
                    ;
                    adaptor.addChild(root_0, FLOAT83_tree);
                    }

                    }
                    break;
                case 3 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:184:4: TRUE
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    TRUE84=(Token)match(input,TRUE,FOLLOW_TRUE_in_primary1162); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    TRUE84_tree = 
                    (LocScriptAST)adaptor.create(TRUE84)
                    ;
                    adaptor.addChild(root_0, TRUE84_tree);
                    }

                    }
                    break;
                case 4 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:184:9: FALSE
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    FALSE85=(Token)match(input,FALSE,FOLLOW_FALSE_in_primary1164); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    FALSE85_tree = 
                    (LocScriptAST)adaptor.create(FALSE85)
                    ;
                    adaptor.addChild(root_0, FALSE85_tree);
                    }

                    }
                    break;
                case 5 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:185:4: VAR ^ ID
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    VAR86=(Token)match(input,VAR,FOLLOW_VAR_in_primary1169); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    VAR86_tree = 
                    (LocScriptAST)adaptor.create(VAR86)
                    ;
                    root_0 = (LocScriptAST)adaptor.becomeRoot(VAR86_tree, root_0);
                    }

                    ID87=(Token)match(input,ID,FOLLOW_ID_in_primary1172); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    ID87_tree = 
                    (LocScriptAST)adaptor.create(ID87)
                    ;
                    adaptor.addChild(root_0, ID87_tree);
                    }

                    }
                    break;
                case 6 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:186:4: MEM_ACCESS ID
                    {
                    MEM_ACCESS88=(Token)match(input,MEM_ACCESS,FOLLOW_MEM_ACCESS_in_primary1177); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_MEM_ACCESS.add(MEM_ACCESS88);


                    ID89=(Token)match(input,ID,FOLLOW_ID_in_primary1179); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_ID.add(ID89);


                    // AST REWRITE
                    // elements: ID, MEM_ACCESS
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocScriptAST)adaptor.nil();
                    // 186:18: -> ^( MEM_ACCESS THIS ID )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:186:21: ^( MEM_ACCESS THIS ID )
                        {
                        LocScriptAST root_1 = (LocScriptAST)adaptor.nil();
                        root_1 = (LocScriptAST)adaptor.becomeRoot(
                        stream_MEM_ACCESS.nextNode()
                        , root_1);

                        adaptor.addChild(root_1, 
                        (LocScriptAST)adaptor.create(THIS, "THIS")
                        );

                        adaptor.addChild(root_1, 
                        stream_ID.nextNode()
                        );

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 7 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:187:4: OPEN_PARENS ! expr0 CLOSE_PARENS !
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    OPEN_PARENS90=(Token)match(input,OPEN_PARENS,FOLLOW_OPEN_PARENS_in_primary1194); if (state.failed) return retval;

                    pushFollow(FOLLOW_expr0_in_primary1197);
                    expr091=expr0();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr091.getTree());

                    CLOSE_PARENS92=(Token)match(input,CLOSE_PARENS,FOLLOW_CLOSE_PARENS_in_primary1199); if (state.failed) return retval;

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "primary"


    public static class stat_return extends ParserRuleReturnScope {
        LocScriptAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "stat"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:190:1: stat : ( expr ';' !| RETURN ^ expr ';' !| defList ';' !| foreach );
    public final LocScriptParser.stat_return stat() throws RecognitionException {
        LocScriptParser.stat_return retval = new LocScriptParser.stat_return();
        retval.start = input.LT(1);


        LocScriptAST root_0 = null;

        Token char_literal94=null;
        Token RETURN95=null;
        Token char_literal97=null;
        Token char_literal99=null;
        LocScriptParser.expr_return expr93 =null;

        LocScriptParser.expr_return expr96 =null;

        LocScriptParser.defList_return defList98 =null;

        LocScriptParser.foreach_return foreach100 =null;


        LocScriptAST char_literal94_tree=null;
        LocScriptAST RETURN95_tree=null;
        LocScriptAST char_literal97_tree=null;
        LocScriptAST char_literal99_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:190:5: ( expr ';' !| RETURN ^ expr ';' !| defList ';' !| foreach )
            int alt23=4;
            switch ( input.LA(1) ) {
            case VAR:
                {
                int LA23_1 = input.LA(2);

                if ( (LA23_1==ID) ) {
                    int LA23_5 = input.LA(3);

                    if ( (LA23_5==OPEN_PARENS) ) {
                        alt23=3;
                    }
                    else if ( (LA23_5==AND||(LA23_5 >= ASSIGN && LA23_5 <= BIT_AND)||LA23_5==BIT_OR||(LA23_5 >= DIV && LA23_5 <= EQUALS)||(LA23_5 >= GREATER_THAN && LA23_5 <= GREATER_THAN_EQUALS)||(LA23_5 >= LESS_THAN && LA23_5 <= MULT_ASSIGN)||LA23_5==NOT_EQUALS||LA23_5==OPEN_BRACK||(LA23_5 >= OR && LA23_5 <= PLUS_ASSIGN)||(LA23_5 >= SHIFT_LEFT && LA23_5 <= SHIFT_RIGHT)||LA23_5==U_SHIFT_RIGHT||(LA23_5 >= XOR && LA23_5 <= 58)||LA23_5==60||(LA23_5 >= 62 && LA23_5 <= 63)) ) {
                        alt23=1;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 23, 5, input);

                        throw nvae;

                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 23, 1, input);

                    throw nvae;

                }
                }
                break;
            case BIT_NEG:
            case FALSE:
            case FLOAT:
            case INT:
            case MEM_ACCESS:
            case MINUS:
            case OPEN_PARENS:
            case TRUE:
            case 58:
            case 60:
                {
                alt23=1;
                }
                break;
            case RETURN:
                {
                alt23=2;
                }
                break;
            case FOR:
                {
                alt23=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 23, 0, input);

                throw nvae;

            }

            switch (alt23) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:190:7: expr ';' !
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    pushFollow(FOLLOW_expr_in_stat1210);
                    expr93=expr();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr93.getTree());

                    char_literal94=(Token)match(input,62,FOLLOW_62_in_stat1212); if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:191:4: RETURN ^ expr ';' !
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    RETURN95=(Token)match(input,RETURN,FOLLOW_RETURN_in_stat1218); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    RETURN95_tree = 
                    (LocScriptAST)adaptor.create(RETURN95)
                    ;
                    root_0 = (LocScriptAST)adaptor.becomeRoot(RETURN95_tree, root_0);
                    }

                    pushFollow(FOLLOW_expr_in_stat1221);
                    expr96=expr();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expr96.getTree());

                    char_literal97=(Token)match(input,62,FOLLOW_62_in_stat1223); if (state.failed) return retval;

                    }
                    break;
                case 3 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:192:4: defList ';' !
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    pushFollow(FOLLOW_defList_in_stat1229);
                    defList98=defList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, defList98.getTree());

                    char_literal99=(Token)match(input,62,FOLLOW_62_in_stat1231); if (state.failed) return retval;

                    }
                    break;
                case 4 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:193:4: foreach
                    {
                    root_0 = (LocScriptAST)adaptor.nil();


                    pushFollow(FOLLOW_foreach_in_stat1237);
                    foreach100=foreach();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, foreach100.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocScriptAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocScriptAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "stat"

    // $ANTLR start synpred1_LocScript
    public final void synpred1_LocScript_fragment() throws RecognitionException {
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:119:4: ( expr2 '?' a= expr0 ':' b= expr0 )
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:119:4: expr2 '?' a= expr0 ':' b= expr0
        {
        pushFollow(FOLLOW_expr2_in_synpred1_LocScript712);
        expr2();

        state._fsp--;
        if (state.failed) return ;

        match(input,63,FOLLOW_63_in_synpred1_LocScript714); if (state.failed) return ;

        pushFollow(FOLLOW_expr0_in_synpred1_LocScript718);
        expr0();

        state._fsp--;
        if (state.failed) return ;

        match(input,61,FOLLOW_61_in_synpred1_LocScript720); if (state.failed) return ;

        pushFollow(FOLLOW_expr0_in_synpred1_LocScript724);
        expr0();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred1_LocScript

    // $ANTLR start synpred2_LocScript
    public final void synpred2_LocScript_fragment() throws RecognitionException {
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:173:4: ( ( primary ) ( ( MEM_ACCESS ID | OPEN_BRACK expr0 CLOSE_BRACK ) )* )
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:173:4: ( primary ) ( ( MEM_ACCESS ID | OPEN_BRACK expr0 CLOSE_BRACK ) )*
        {
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:173:4: ( primary )
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:173:5: primary
        {
        pushFollow(FOLLOW_primary_in_synpred2_LocScript1060);
        primary();

        state._fsp--;
        if (state.failed) return ;

        }


        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:174:3: ( ( MEM_ACCESS ID | OPEN_BRACK expr0 CLOSE_BRACK ) )*
        loop25:
        do {
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==MEM_ACCESS||LA25_0==OPEN_BRACK) ) {
                alt25=1;
            }


            switch (alt25) {
        	case 1 :
        	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:175:3: ( MEM_ACCESS ID | OPEN_BRACK expr0 CLOSE_BRACK )
        	    {
        	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:175:3: ( MEM_ACCESS ID | OPEN_BRACK expr0 CLOSE_BRACK )
        	    int alt24=2;
        	    int LA24_0 = input.LA(1);

        	    if ( (LA24_0==MEM_ACCESS) ) {
        	        alt24=1;
        	    }
        	    else if ( (LA24_0==OPEN_BRACK) ) {
        	        alt24=2;
        	    }
        	    else {
        	        if (state.backtracking>0) {state.failed=true; return ;}
        	        NoViableAltException nvae =
        	            new NoViableAltException("", 24, 0, input);

        	        throw nvae;

        	    }
        	    switch (alt24) {
        	        case 1 :
        	            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:175:4: MEM_ACCESS ID
        	            {
        	            match(input,MEM_ACCESS,FOLLOW_MEM_ACCESS_in_synpred2_LocScript1074); if (state.failed) return ;

        	            match(input,ID,FOLLOW_ID_in_synpred2_LocScript1076); if (state.failed) return ;

        	            }
        	            break;
        	        case 2 :
        	            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:176:4: OPEN_BRACK expr0 CLOSE_BRACK
        	            {
        	            match(input,OPEN_BRACK,FOLLOW_OPEN_BRACK_in_synpred2_LocScript1092); if (state.failed) return ;

        	            pushFollow(FOLLOW_expr0_in_synpred2_LocScript1094);
        	            expr0();

        	            state._fsp--;
        	            if (state.failed) return ;

        	            match(input,CLOSE_BRACK,FOLLOW_CLOSE_BRACK_in_synpred2_LocScript1096); if (state.failed) return ;

        	            }
        	            break;

        	    }


        	    }
        	    break;

        	default :
        	    break loop25;
            }
        } while (true);


        }

    }
    // $ANTLR end synpred2_LocScript

    // $ANTLR start synpred3_LocScript
    public final void synpred3_LocScript_fragment() throws RecognitionException {
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:178:4: ( primary '++' )
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocScript.g:178:4: primary '++'
        {
        pushFollow(FOLLOW_primary_in_synpred3_LocScript1118);
        primary();

        state._fsp--;
        if (state.failed) return ;

        match(input,58,FOLLOW_58_in_synpred3_LocScript1120); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred3_LocScript

    // Delegated rules

    public final boolean synpred2_LocScript() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred2_LocScript_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred1_LocScript() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred1_LocScript_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred3_LocScript() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred3_LocScript_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


 

    public static final BitSet FOLLOW_stat_in_start458 = new BitSet(new long[]{0x14A20200C8D00100L});
    public static final BitSet FOLLOW_EOF_in_start461 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_stat_in_block482 = new BitSet(new long[]{0x14A20200C8D00102L});
    public static final BitSet FOLLOW_FOR_in_foreach504 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_OPEN_PARENS_in_foreach506 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_defCore_in_foreach508 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_61_in_foreach510 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr_in_foreach512 = new BitSet(new long[]{0x0000000000002000L});
    public static final BitSet FOLLOW_CLOSE_PARENS_in_foreach514 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_OPEN_BRACE_in_foreach516 = new BitSet(new long[]{0x14A20200C8D00900L});
    public static final BitSet FOLLOW_block_in_foreach518 = new BitSet(new long[]{0x0000000000000800L});
    public static final BitSet FOLLOW_CLOSE_BRACE_in_foreach520 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_def_in_defList550 = new BitSet(new long[]{0x0800000000000002L});
    public static final BitSet FOLLOW_59_in_defList553 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_def_in_defList556 = new BitSet(new long[]{0x0800000000000002L});
    public static final BitSet FOLLOW_defCore_in_def569 = new BitSet(new long[]{0x0000000000000042L});
    public static final BitSet FOLLOW_ASSIGN_in_def572 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr_in_def574 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VAR_in_defCore599 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_ID_in_defCore602 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_OPEN_PARENS_in_defCore604 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_ID_in_defCore607 = new BitSet(new long[]{0x0000000000002000L});
    public static final BitSet FOLLOW_CLOSE_PARENS_in_defCore609 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expr0_in_expr623 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VAR_in_expr0643 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_ID_in_expr0645 = new BitSet(new long[]{0x0000100900020040L});
    public static final BitSet FOLLOW_ASSIGN_in_expr0650 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_PLUS_ASSIGN_in_expr0654 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_MINUS_ASSIGN_in_expr0658 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_MULT_ASSIGN_in_expr0662 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_DIV_ASSIGN_in_expr0666 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr0_in_expr0669 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expr1_in_expr0689 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expr2_in_expr1712 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_expr1714 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr0_in_expr1718 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_61_in_expr1720 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr0_in_expr1724 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expr2_in_expr1743 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expr3_in_expr2755 = new BitSet(new long[]{0x0000040000000002L});
    public static final BitSet FOLLOW_OR_in_expr2758 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr3_in_expr2761 = new BitSet(new long[]{0x0000040000000002L});
    public static final BitSet FOLLOW_expr4_in_expr3775 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_AND_in_expr3778 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr4_in_expr3781 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_expr5_in_expr4795 = new BitSet(new long[]{0x0000000000000202L});
    public static final BitSet FOLLOW_BIT_OR_in_expr4798 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr5_in_expr4801 = new BitSet(new long[]{0x0000000000000202L});
    public static final BitSet FOLLOW_expr6_in_expr5815 = new BitSet(new long[]{0x0200000000000002L});
    public static final BitSet FOLLOW_XOR_in_expr5818 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr6_in_expr5821 = new BitSet(new long[]{0x0200000000000002L});
    public static final BitSet FOLLOW_expr7_in_expr6835 = new BitSet(new long[]{0x0000000000000082L});
    public static final BitSet FOLLOW_BIT_AND_in_expr6838 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr7_in_expr6841 = new BitSet(new long[]{0x0000000000000082L});
    public static final BitSet FOLLOW_expr8_in_expr7855 = new BitSet(new long[]{0x0000004000040002L});
    public static final BitSet FOLLOW_set_in_expr7858 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr8_in_expr7865 = new BitSet(new long[]{0x0000004000040002L});
    public static final BitSet FOLLOW_expr9_in_expr8879 = new BitSet(new long[]{0x0000000033000002L});
    public static final BitSet FOLLOW_set_in_expr8882 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr9_in_expr8893 = new BitSet(new long[]{0x0000000033000002L});
    public static final BitSet FOLLOW_expr10_in_expr9907 = new BitSet(new long[]{0x004C000000000002L});
    public static final BitSet FOLLOW_set_in_expr9910 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr10_in_expr9919 = new BitSet(new long[]{0x004C000000000002L});
    public static final BitSet FOLLOW_expr11_in_expr10933 = new BitSet(new long[]{0x0000080080000002L});
    public static final BitSet FOLLOW_set_in_expr10936 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr11_in_expr10943 = new BitSet(new long[]{0x0000080080000002L});
    public static final BitSet FOLLOW_expr12_in_expr11957 = new BitSet(new long[]{0x0000000600010002L});
    public static final BitSet FOLLOW_set_in_expr11960 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr12_in_expr11969 = new BitSet(new long[]{0x0000000600010002L});
    public static final BitSet FOLLOW_MINUS_in_expr12983 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr12_in_expr12985 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BIT_NEG_in_expr12998 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr12_in_expr121001 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_58_in_expr121006 = new BitSet(new long[]{0x00A0020048500000L});
    public static final BitSet FOLLOW_expr13_in_expr121008 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_60_in_expr121021 = new BitSet(new long[]{0x00A0020048500000L});
    public static final BitSet FOLLOW_expr13_in_expr121023 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expr13_in_expr121036 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_in_expr131060 = new BitSet(new long[]{0x0000010040000002L});
    public static final BitSet FOLLOW_MEM_ACCESS_in_expr131074 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_ID_in_expr131076 = new BitSet(new long[]{0x0000010040000002L});
    public static final BitSet FOLLOW_OPEN_BRACK_in_expr131092 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr0_in_expr131094 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_CLOSE_BRACK_in_expr131096 = new BitSet(new long[]{0x0000010040000002L});
    public static final BitSet FOLLOW_primary_in_expr131118 = new BitSet(new long[]{0x0400000000000000L});
    public static final BitSet FOLLOW_58_in_expr131120 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_in_expr131133 = new BitSet(new long[]{0x1000000000000000L});
    public static final BitSet FOLLOW_60_in_expr131135 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INT_in_primary1155 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FLOAT_in_primary1157 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TRUE_in_primary1162 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FALSE_in_primary1164 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VAR_in_primary1169 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_ID_in_primary1172 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MEM_ACCESS_in_primary1177 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_ID_in_primary1179 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_OPEN_PARENS_in_primary1194 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr0_in_primary1197 = new BitSet(new long[]{0x0000000000002000L});
    public static final BitSet FOLLOW_CLOSE_PARENS_in_primary1199 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expr_in_stat1210 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_62_in_stat1212 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RETURN_in_stat1218 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr_in_stat1221 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_62_in_stat1223 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_defList_in_stat1229 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_62_in_stat1231 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_foreach_in_stat1237 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expr2_in_synpred1_LocScript712 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_synpred1_LocScript714 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr0_in_synpred1_LocScript718 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_61_in_synpred1_LocScript720 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr0_in_synpred1_LocScript724 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_in_synpred2_LocScript1060 = new BitSet(new long[]{0x0000010040000002L});
    public static final BitSet FOLLOW_MEM_ACCESS_in_synpred2_LocScript1074 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_ID_in_synpred2_LocScript1076 = new BitSet(new long[]{0x0000010040000002L});
    public static final BitSet FOLLOW_OPEN_BRACK_in_synpred2_LocScript1092 = new BitSet(new long[]{0x14A00200C8500100L});
    public static final BitSet FOLLOW_expr0_in_synpred2_LocScript1094 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_CLOSE_BRACK_in_synpred2_LocScript1096 = new BitSet(new long[]{0x0000010040000002L});
    public static final BitSet FOLLOW_primary_in_synpred3_LocScript1118 = new BitSet(new long[]{0x0400000000000000L});
    public static final BitSet FOLLOW_58_in_synpred3_LocScript1120 = new BitSet(new long[]{0x0000000000000002L});

}